Dynamic memory management

From Cppreference

C++ Standard Library
Language Utilities library Strings library Containers library Algorithms library Iterators library Numerics library Input/output library Localizations library Regular expressions library (C++0x feature) Atomic operations library (C++0x feature) Thread support library (C++0x feature)
Utilities library
Dynamic memory management
Template:cpp/memory/sidebar content

Contents 1 Low level memory management 2 Allocators 3 Uninitialized storage 4 Smart pointers 5 Garbage collector support 6 Miscellaneous 7 C library

[edit] Low level memory management

[edit] Allocators

Allocators are class templates encapsulating memory allocation strategy. This allows generic containers to decouple memory management from the data itself.

allocator	The default allocator. Before C++0x any allocator had to provide the interface (but not necessarily implementation), identical to one of the default allocator, also it could not have nonstatic data. In C++x0 these two rules are relaxed, allocators can be implemented through allocator_traits (class template)
allocator_traits (C++0x)	Provides standard interface to access the interface and properties of particular allocator (class template)
scoped_allocator_adaptor (C++0x)	Implements multi-level allocator, which can be used in multi-level containers to specify allocator for elements in each particular level (class template)

[edit] Uninitialized storage

Several utilities are provided to initialize raw storage

uninitialized_copy (C++0x)	copies a range of objects to uninitialized area of memory (function template)
uninitialized_copy_n (C++0x)	copies a number of objects to uninitialized area of memory (function template)
uninitialized_fill (C++0x)	copies an object to uninitialized area of memory (function template)
uninitialized_fill_n (C++0x)	copies an object to uninitialized area of memory (function template)

[edit] Smart pointers

Smart pointers enable easier and less error prone object lifetime management.

unique_ptr (C++0x)	provides pointer ownership semantics, i.e. only one unique_ptr object can own the given object, which is destroyed when the unique_ptr object referring to it is destroyed (class template)
shared_ptr (C++0x)	provides shared pointer ownership semantics, i.e. multiple shared_ptr instances can manages an object, which is destroyed when the last shared_ptr object referring to it is destroyed (class template)
weak_ptr (C++0x)	holds weak reference to an object already managed by shared_ptr, i.e. the object can be destroyed even there is weak_ptr instance referring to it (class template)
enable_shared_from_this (C++0x)	allows an object to get a shared_ptr referring to itself (class template)
bad_weak_ptr (C++0x)	an exception that is thrown when accessing a weak_ptr which refers to already destroyed object (class template)
auto_ptr (deprecated)	provides unique pointer ownership semantics. This class is deprecated, use unique_ptr instead. (class template)

[edit] Garbage collector support

declare_reachable (C++0x)	declares that an object can not be recycled even if there is no pointer referring to it (function template)
undeclare_reachable (C++0x)	declares that an object can not be recycled even if there is no pointer referring to it (function template)
declare_no_pointers (C++0x)	declares that a memory area does not contain pointers (function template)
undeclare_no_pointers (C++0x)	declares that a memory area can have pointers (function template)
pointer_safety (C++0x)	returns the implementation's pointer safety (function template)

[edit] Miscellaneous

pointer_traits (C++0x)	provides interface to query information about several properties of pointer-like types (class template)
address_of (C++0x)	obtains actual address of an object, even if the & operator is overloaded (function template)
align (C++0x)	aligns a pointer in a buffer (function template)

[edit] C library